Threading in C#
Threading is commonly used by developers to increase the performance of applications. The thread is a light-weight process. In Computer Science, a thread is the smallest sequenced program instructions that can be managed independently by a thread scheduler, which is typically a part of operating system (Wikipedia).
For creating threading application there some important methods which used regularly for implementing threading.
1: Thread Join
2: Thread Sleep
3: Thread Abort
Types of Threads in C#-
There are two types of Thread in C# i.e. Foreground Thread and Background Thread. Further, let's see the uses of these threads.
The thread is the smallest unit of execution within a process. Multithreading is the ability to have multiple threads in memory at a given time and switch among them to handle multiple operations at the same time. Microsoft ’s.Net Framework provides excellent support for working with threads.
Often, c# supports the relevant execution of the task or program code through multithreading. If we want to summarize about multi-threads, "Multithreading consists of two or more program codes that run concurrently without affecting each other and each program code is called a thread". Use “System. Threading” namespace to implement multithreading in your program. Let us see a simple example of creating multithreading in c sharp. There are two types to create the thread in C#, first one is through the Thread Class and the second one is through the Thread-Start Delegate.
About to ThreadPool
Into the C#, the ThreadPool is basically a collection of threads that you can use to run asynchronous tasks. The ThreadPool handles pretty much everything for you — the application developer just provides a method to execute and the ThreadPool executes it when a thread becomes available.
Example - 1.
using System;
using System.Threading;
namespace MultithreadingApplication
{
class ThreadCreationProgram
{
public static void CallToChildThread()
{
Console.WriteLine("Child thread starts");
}
static void Main(string[] args)
{
ThreadStart childref = new ThreadStart(CallToChildThread);
Console.WriteLine("In Main: Creating the Child thread");
Thread childThread = new Thread(childref);
childThread.Start();
Console.ReadKey();
}
}
}
Example-2.
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Multithread
{
class Program
{
static void Main(string[] args)
{
Thread table2 = new Thread(new ThreadStart(tableA));
Thread table3 = new Thread(new ThreadStart(tableB));
table2.Start();
table3.Start();
Console.Read();
}
public static void tableA()
{
for (int i = 1; i < 11; i++)
Console.WriteLine("2*" + i + " = " + 2 * 2000);
}
public static void tableB()
{
for (int j = 1; j < 11; j++)
Console.WriteLine("3*" + j + " = " + 3 * j);
}
}
}
Example - 3.
using System;
using System.Threading;
namespace BarrierEx
{
class Program
{
static Barrier _barrier = new Barrier(4, barrier => Console.WriteLine());
static void Main(string[] args)
{
Thread t1 = new Thread(DemoMethod);
new Thread(DemoMethod).Start();
new Thread(DemoMethod).Start();
new Thread(DemoMethod).Start();
t1.Start();
Console.ReadKey();
}
static void DemoMethod()
{
Thread.CurrentThread.Name = "MyThread";
for (int i = 0; i <=6; i++)
{
Console.WriteLine(i + " " + Thread.CurrentThread.Name);
_barrier.SignalAndWait();
}
}
}
}
Thanks...!!! for Reading this article
Khushi Singh
12-Mar-2025C# developers utilize Threading as a basic concept to perform multiple tasks simultaneously which increases their application speed and efficiency. The System.Threading namespace of C# includes different classes and methods which allow developers to create and administer threads that enable multitasking operations effectively.
All processes contain threads as their basic execution elements. The Thread class as part of C# programming allows developers to create and administer threading processes which execute code simultaneously. .Default operation for C# would execute a single thread of an application yet developers can create additional concurrent threads.
Using the Thread class in C# together with the Start() method allows programmers to begin new execution paths which results in thread creation. The comprehensive management of threads becomes challenging because it requires many resources and might produce race conditions as well as deadlocks. C# offers ThreadPool as a thread management system that operates worker threads to lower resource needs and boost efficiency.
C# includes the Task Parallel Library (TPL) as its high-level multithreading solution to simplify thread management and boost performance. Developers can produce and supervise asynchronous operations through the Task class which exists within System.Threading.Tasks. C# provides the Async/Await feature as a powerful tool to perform non-blocking execution which results in better application responsiveness mainly for tasks based on input and output operations.
Lock, mutex, semaphore and monitor serve as synchronization tools that protect shared resources from contamination by concurrent threads or ensure thread safety. Thread management needs proper execution because it prevents deadlocks, starvation and performance bottlenecks from occurring.
Using the multithreading capabilities in C# allows developers to build applications that respond fast with high performance mainly in situations where background processes, parallel computations and web applications with multiple client demands exist.